package com.bjpowernode.javase.collection.review;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/*
TreeSet:
    无序不可重复，但是会按照元素的大小自动排序。
    底层为二叉树
    取：set集合无序不可重复，没有下标,也取不出，只能遍历。
 */
public class TreeSetTest {
    public static void main(String[] args) {
        //创建集合
        //TreeSet<Integer> ts = new TreeSet<>();
        //编写比较器可以改变比较规则
        TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;//自动拆箱
            }
        });


        //添加元素
        ts.add(10);
        ts.add(2);
        ts.add(6);
        ts.add(5);

        //遍历（迭代器的方式）
        Iterator it = ts.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        for(Iterator it2 = ts.iterator();it2.hasNext();){
            System.out.println("==>"+it2.next());
        }

        //遍历（foreach）
        for(Integer in : ts){
            System.out.println(in);
        }

        //TreeSet集合中存储自定义类型A
        TreeSet<A> setA = new TreeSet<>();
        setA.add(new A(10));
        setA.add(new A(5));
        setA.add(new A(4));
        setA.add(new A(8));

        //遍历
       for(A a : setA){
           System.out.println(a);
       }

        //TreeSet集合中存储自定义类型B
        bComparator bcomparator = new bComparator();
        //TreeSet<B> b = new TreeSet<>(bcomparator);
        //匿名内部类
        TreeSet<B> b = new TreeSet<>(new Comparator<B>(){
            public int compare(B b1,B b2){
                return b1.i - b2.i;
            }
        });
        b.add(new B(1000));
        b.add(new B(1));
        b.add(new B(15));
        b.add(new B(13));

       for (B b1 : b){
           System.out.println(b1);
       }



    }
}
class A implements Comparable<A>{
    int i;
    public A(int i){
        this.i = i;
    }

    public String toString(){
        //return String.valueOf(i);
        return "A=[" +
                i + "]";
    }

    public int compareTo(A a){
        //return this.i - a.i;
        return  a.i - this.i;
    }

    /*@Override
    public int compareTo(Object o) {
        return 0;
    }*/
}

class B{
    int i;
    public B(int i){
        this.i = i;
    }
    public String toString(){
        return "B=[" + i + "]" ;
    }
}

class bComparator implements Comparator<B>{
    @Override
    public int compare(B o1, B o2) {
        return o1.i - o2.i;
    }
}